EP0. 대규모 언어 모델(LLM) 핵심 원리

LLM은 문맥에 맞는 '다음 토큰'을 확률적으로 예측하는 자기회귀 기계이며, 그 예측 엔진이 트랜스포머·어텐션이고, 이 두뇌가 곧 AI 에이전트의 사고 중심이다.

0. 사전 필수 용어 (선행지식)

본 강의를 이해하려면 아래 용어를 먼저 잡아두면 좋습니다. 각 용어는 §1~§6 본문에서 반복 등장합니다.

1. 확률 분포 (Probability distribution): 여러 후보 중 각각이 나올 가능성을 숫자로 나눈 것입니다. 주사위에서 각 눈이 1/6인 것과 같습니다. LLM은 "다음 토큰 후보"에 대해 이 분포를 계산합니다. → §1·§6에서 "다음 토큰 예측"의 실체입니다.
2. 벡터·임베딩 (Vector / Embedding): 단어나 토큰을 숫자 배열로 바꾼 표현입니다. 색을 RGB 숫자 3개로 나타내듯, 의미를 숫자 좌표로 나타낸 것입니다. → §3 인코더가 만들어내는 "조밀한 표현"이 이것입니다.
3. 신경망 매개변수 (Parameter): 모델이 학습으로 조정하는 내부 숫자(가중치)입니다. 요리사의 '손맛 설정값' 수십억 개라고 생각하면 됩니다. → §3·§9의 "수십억 개 매개변수"가 이것입니다.
4. 아키텍처 (Architecture): 신경망을 어떤 부품으로 어떻게 연결했는지에 대한 설계도입니다. 같은 재료라도 건물 설계가 다르듯, LLM도 설계에 따라 성격이 달라집니다. → §3·§8의 트랜스포머 3종이 서로 다른 설계입니다.
5. 추론 (Inference): 이미 학습된 모델에 입력을 넣어 출력을 뽑는 실행 단계입니다. 학습(training)과 구분됩니다. → §4의 코드 실습이 모두 추론 단계입니다.

선행지식이 부족하다면 Hugging Face Course(https://huggingface.co/learn)의 트랜스포머 입문 유닛을 먼저 참고합니다.

1. 주제 정의

대규모 언어 모델(LLM, Large Language Model) 은 방대한 텍스트로 훈련되어 인간 언어를 이해·생성하는 신경망 모델입니다. 겉보기에는 대화가 매끄러워 '마법' 같지만, 그 목표는 매우 단순합니다 — 주어진 문맥에서 다음에 올 말(토큰)을 예측하는 것 하나입니다.

핵심 아이디어: LLM은 "세상에서 제일 정교한 자동완성 게임"을 수행하는 확률적 다음-토큰 예측기입니다.

2. 풀려는 문제

LLM은 '언어를 다루는 일반 문제'를 확률 예측 하나로 통합해 풉니다. 실무에서 마주치는 대표 시나리오는 다음과 같습니다.

• 문제 1 — 텍스트 생성의 일관성: 사람이 규칙을 일일이 코딩하지 않고도 문맥에 맞는 문장을 이어가야 합니다. → 다음-토큰 예측 + 자기회귀 루프로 해결.
• 문제 2 — 언어 단위의 표현: 세상의 모든 단어를 사전에 등록할 수 없습니다. → '토큰'이라는 하위 단어 조각으로 조합해 해결(영어는 약 3만 2천 토큰으로 거의 모든 단어 조합 가능).
• 문제 3 — 문맥 내 중요도 판단: "프랑스의 수도는 __"에서 '프랑스'에 집중해야 '파리'가 나옵니다. → 어텐션(Attention)으로 해결.
• 문제 4 — 무한 생성 방지: 생성이 끝없이 이어지면 안 됩니다. → 시퀀스 종료(EOS) 토큰으로 정지.

💡 실무 노하우: 위 4개는 '한계'이자 동시에 '설계 포인트'입니다. 예컨대 EOS를 잘못 다루면 응답이 잘리거나(조기 종료) 토큰을 낭비합니다(늦은 종료). 프로덕션에서는 max_tokens와 stop 조건을 함께 설계해 비용·안정성을 잡습니다.

3. 핵심 개념·구조

LLM은 다음 요소로 구성됩니다.

• 토큰(Token): LLM이 처리하는 정보의 최소 단위. 단어 또는 단어의 일부(하위 단어). 레고 블록처럼 조합됩니다("흥미"+"롭다" → "흥미롭다").
• 자기회귀(Autoregressive) 루프: 예측한 토큰을 다시 입력에 붙여 다음 토큰을 예측하는 순환. "자기가 뱉은 말을 다시 먹고 다음 말을 뱉는" 과정.
• 트랜스포머(Transformer): 이 예측을 돌리는 엔진 아키텍처. 심장에 어텐션이 있습니다("Attention Is All You Need").
• 어텐션(Attention): 문맥 속 각 단어의 중요도에 가중치를 두어 핵심에 집중하게 하는 기술.
• 인코더/디코더/시퀀스-투-시퀀스: 트랜스포머의 3가지 계열 구조(§8에서 비교).

[입력 시퀀스] ─▶ 토큰화 ─▶ ┌─────────────────────────┐
                            │  트랜스포머 (어텐션)      │
                            │  다음 토큰 확률분포 계산  │
                            └───────────┬─────────────┘
                                        ▼
                              가장 그럴듯한 다음 토큰 선택
                                        ▼
              ┌──── 출력에 붙여 다시 입력으로 (자기회귀) ────┐
              │                                              │
              └──── EOS 토큰 예측 시 정지 ◀──────────────────┘

4. 구현 가이드 (Do It Yourself)

시작 전 (Before you begin)

이 섹션을 완료하면 강의의 개념(토큰화·자기회귀·EOS·API 호출)을 실제 코드로 구현하고 검증할 수 있습니다.

선수 조건: - Python 3.10+ - pip install tiktoken transformers torch anthropic - API 키 (Anthropic) — 환경 변수 ANTHROPIC_API_KEY 설정

소요 시간: 약 15분.

Step 1 — 토큰이 무엇인지 직접 확인

목표: 문장이 '단어'가 아니라 '토큰'으로 쪼개지는 것을 눈으로 확인합니다.

다음 코드를 tokens.py 에 추가합니다.

import tiktoken

enc = tiktoken.get_encoding("cl100k_base")
ids = enc.encode("흥미롭다 interesting")
print(ids, len(ids))

이 코드는 문자열을 토큰 ID 목록으로 인코딩합니다. 한국어는 영어보다 토큰이 더 잘게 쪼개지는 것을 관찰할 수 있습니다.

⚠️ 주의: 토큰 수 = 비용입니다. 같은 의미라도 언어·인코딩에 따라 토큰 수가 크게 달라져 API 요금이 달라집니다.

💡 실무 노하우: 요청 전 len(enc.encode(text))로 토큰을 미리 세어 max_tokens·컨텍스트 한도를 넘지 않도록 방어합니다.

📚 참고: OpenAI tiktoken(https://github.com/openai/openai-python)과 HuggingFace AutoTokenizer(https://github.com/huggingface/transformers).

✅ 확인: Step 1 완료. 출력된 토큰 개수가 단어 개수보다 많으면 성공입니다.

Step 2 — 자기회귀 생성과 EOS 토큰 관찰

목표: 모델이 토큰을 하나씩 이어 붙이다가 EOS에서 멈추는 것을 확인합니다.

다음 코드를 autoregressive.py 에 추가합니다.

from transformers import AutoTokenizer, AutoModelForCausalLM

tok = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")
inputs = tok("The capital of France is", return_tensors="pt")
out = model.generate(**inputs, max_new_tokens=10, eos_token_id=tok.eos_token_id)
print(tok.decode(out[0]))
print("EOS id:", tok.eos_token_id)

이 코드는 디코더 기반 모델(GPT-2)이 다음 토큰을 반복 예측하며, eos_token_id를 만나면 생성을 멈추도록 합니다.

⚠️ 주의: EOS 토큰 ID는 모델마다 다릅니다. GPT 계열과 Llama 계열이 서로 다른 종료 토큰을 씁니다 — 모델을 바꾸면 종료 처리 코드도 점검합니다.

💡 실무 노하우: 로컬 추론은 VRAM 제약을 받습니다(예: 4GB GPU). 큰 모델은 vLLM(https://github.com/vllm-project/vllm)이나 Ollama(https://github.com/ollama/ollama)로 양자화·서빙합니다.

📚 참고: HuggingFace Transformers generate() 가이드(https://github.com/huggingface/transformers).

✅ 확인: Step 2 완료. 생성이 max_new_tokens 이전에 EOS로 멈추거나 문장이 자연스럽게 끝나면 성공입니다.

Step 3 — 공식 SDK로 실제 LLM 호출

목표: 프로덕션급 디코더 기반 LLM을 공식 SDK로 호출합니다.

다음 코드를 call_llm.py 에 추가합니다.

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
msg = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=256,
    messages=[{"role": "user", "content": "프랑스의 수도는?"}],
)
print(msg.content[0].text)

이 코드는 어텐션이 문맥('프랑스')에 집중해 '파리'를 예측하도록 유도하는 프롬프트를 보냅니다.

⚠️ 주의: API 키를 코드에 직접 박지 마세요. 환경 변수 ANTHROPIC_API_KEY를 사용합니다.

💡 실무 노하우: 사용자 체감 지연을 줄이려면 스트리밍을 씁니다 — with client.messages.stream(...) as s: for text in s.text_stream: .... UX(빠른 첫 토큰)와 비용(동일 토큰)의 트레이드오프를 이해하고 선택합니다.

📚 참고: Anthropic Python SDK(https://github.com/anthropics/anthropic-sdk-python), Anthropic Quickstart(https://platform.claude.com/docs/en/intro).

✅ 확인: Step 3 완료. 응답 텍스트가 출력되면 성공입니다.

Step 마지막 — 동작 확인 (테스트)

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
r = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=64,
    messages=[{"role": "user", "content": "한 단어로: 프랑스의 수도는?"}],
)
print(r.content[0].text)

예상 출력:

파리

5. 적용 사례 (공신력 오픈소스)

• LangChain (https://github.com/langchain-ai/langchain) — Chain·Agent 오케스트레이션
• LlamaIndex (https://github.com/run-llama/llama_index) — RAG·인덱싱
• Anthropic Python SDK (https://github.com/anthropics/anthropic-sdk-python) — Claude 호출
• OpenAI Python SDK (https://github.com/openai/openai-python) — GPT 호출·tiktoken
• HuggingFace Transformers (https://github.com/huggingface/transformers) — 토크나이저·generate
• vLLM (https://github.com/vllm-project/vllm) — 고성능 디코더 서빙
• Ollama (https://github.com/ollama/ollama) — 로컬 LLM 실행
• LiteLLM (https://github.com/BerriAI/litellm) — 멀티 벤더 통합 호출
• Spring AI (https://github.com/spring-projects/spring-ai) — JVM 진영 LLM 연동
• LangChain4j (https://github.com/langchain4j/langchain4j) — Java LLM 프레임워크

📚 참고: 위 OSS들은 모두 GitHub stars ≥ 5K 또는 Anthropic·OpenAI·HuggingFace 공식 SDK입니다.

💡 실무 노하우: 여러 벤더를 오갈 계획이면 LiteLLM 같은 추상화가 유용하지만, 세밀한 기능(스트리밍·구조화 출력·캐싱)은 공식 SDK를 직접 호출하는 편이 안정적입니다(룰: Tier 1 SDK 우선).

6. 핵심 원리

1. 다음-토큰 예측: LLM의 유일한 임무는 "주어진 문장을 완성"하는 것 — 매 스텝 다음 토큰의 확률 분포를 계산해 하나를 고릅니다.
2. 자기회귀 + 어텐션: 고른 토큰을 입력에 다시 붙여(자기회귀) 반복하되, 각 스텝에서 어텐션이 문맥 내 중요 토큰에 가중치를 둡니다.

7. 변형·확장

같은 '생성' 목표를 다른 방식으로 달성할 수 있습니다.

• 스트리밍(streaming): 토큰을 생성 즉시 전송 → 첫 응답 체감 지연 최소화.
• 배치(batch): 다수 요청을 모아 처리 → 처리량·비용 효율 우선.
• 비동기(async): 다수 호출을 동시에 대기 → I/O 바운드 작업 병렬화.
• 디코딩 전략: greedy / temperature 샘플링 / top-p 로 창의성-일관성 조절.

8. 다른 도구·접근과의 비교 (3-way)

• vs 인코더 모델(예: BERT): 글을 읽고 의미를 조밀한 표현(임베딩)으로 압축 — 이해·검색·분류에 강함. 생성은 약함.
• vs 디코더 모델(예: Llama·GPT): 한 번에 한 토큰씩 새 시퀀스를 생성 — 챗봇·코드 생성에 강함. 현대 LLM 대부분이 이 계열.
• vs 시퀀스-투-시퀀스(예: T5): 인코더가 이해한 뒤 디코더가 생성 — 번역·요약 등 입력→변환→출력 과제에 적합.

9. 한계·트레이드오프

1. 환각(Hallucination): 확률적 패턴 조합이므로 사실과 다른 그럴듯한 출력을 낼 수 있습니다.
2. 비용·지연(latency): 토큰 수에 비례해 비용·시간이 증가합니다(입력·출력 토큰 요금이 다름).
3. 문맥·데이터 보안: 프롬프트에 넣은 민감 정보가 로그·캐시에 남을 수 있어 마스킹·온프레미스 서빙이 필요할 수 있습니다.

10. 최신 권장 패턴 (2025 이후)

• 구조화 출력(Structured output)·function calling: 자유 텍스트 대신 JSON 스키마로 응답을 받아 파싱 안정성을 확보합니다.
• 프롬프트 캐싱: 반복되는 시스템 프롬프트를 캐시해 비용·지연을 줄입니다.
• 관측성(Observability): 프롬프트 버저닝·트레이싱으로 회귀를 추적합니다.
• 에러 처리: retry·fallback·circuit breaker로 rate limit·장애에 대비합니다.

11. 메타인지 자기평가

본인 시스템에 위 원리를 적용할 수 있는지 점검합니다.

Step 1 — 현재 상태 점검

grep -rn "eos_token\|max_tokens\|stream(" your_project/

Step 2 — 적용 가능성 평가 - 요청 전에 토큰 수를 세어 비용·컨텍스트 한도를 방어하고 있는가? - 모델 교체 시 EOS/종료 조건을 점검하는 체크리스트가 있는가?

Step 3 — 점진 적용 1. 공식 SDK 직접 호출로 최소 예제를 만든다(Step 3 코드). 2. 스트리밍·구조화 출력·프롬프트 캐싱을 하나씩 도입해 UX·비용을 측정한다.